package com.zapi.ai.service;

import com.alibaba.dashscope.aigc.generation.Generation;
import com.alibaba.dashscope.aigc.generation.GenerationParam;
import com.alibaba.dashscope.aigc.generation.GenerationResult;
import com.alibaba.dashscope.common.Message;
import com.alibaba.dashscope.common.Role;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.zapi.ai.config.QwenConfig;
import com.zapi.ai.model.ApiMetadata;
import com.zapi.ai.model.FunctionCallRequest;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

/**
 * AI Function Calling服务
 * 将用户自然语言转换为API调用
 */
@Slf4j
@Service
@RequiredArgsConstructor
public class AiFunctionCallingService {
    
    private final QwenConfig qwenConfig;
    private final ApiScannerService apiScannerService;
    private final ObjectMapper objectMapper = new ObjectMapper();
    
    /**
     * 分析用户意图，选择合适的API
     * 
     * @param userMessage 用户消息
     * @return Function Call请求，如果不需要调用API则返回null
     */
    public FunctionCallRequest analyzeIntent(String userMessage) {
        try {
            // 获取API文档
            String apiDoc = apiScannerService.generateApiDocumentation();
            
            // 构建系统提示词
            String systemPrompt = buildSystemPrompt(apiDoc);
            
            // 调用AI分析意图
            List<Message> messages = new ArrayList<>();
            messages.add(Message.builder()
                    .role(Role.SYSTEM.getValue())
                    .content(systemPrompt)
                    .build());
            messages.add(Message.builder()
                    .role(Role.USER.getValue())
                    .content(userMessage)
                    .build());
            
            Generation gen = new Generation();
            GenerationParam param = GenerationParam.builder()
                    .apiKey(qwenConfig.getApiKey())
                    .model(qwenConfig.getModel())
                    .messages(messages)
                    .resultFormat(GenerationParam.ResultFormat.MESSAGE)
                    .temperature(0.3f) // 降低温度，使结果更确定
                    .build();
            
            GenerationResult result = gen.call(param);
            String aiResponse = result.getOutput().getChoices().get(0).getMessage().getContent();
            
            log.info("AI意图分析结果: {}", aiResponse);
            
            // 解析AI返回的JSON
            return parseFunctionCall(aiResponse);
            
        } catch (Exception e) {
            log.error("意图分析失败: " + e.getMessage(), e);
            return null;
        }
    }
    
    /**
     * 构建系统提示词
     */
    private String buildSystemPrompt(String apiDoc) {
        return "你是一个智能API调用助手。你的任务是分析用户的自然语言请求，判断是否需要调用系统API，" +
                "如果需要，选择合适的API并生成调用参数。\n\n" +
                "以下是系统可用的API列表：\n" +
                apiDoc + "\n\n" +
                "请按以下规则工作：\n" +
                "1. 判断用户请求是否需要调用API（如果是闲聊、咨询等不需要操作数据的请求，返回 {\"needCall\": false}）\n" +
                "2. 如果需要调用API，返回JSON格式：\n" +
                "{\n" +
                "  \"needCall\": true,\n" +
                "  \"method\": \"GET/POST/PUT/DELETE\",\n" +
                "  \"path\": \"/api/path\",\n" +
                "  \"parameters\": {参数键值对},\n" +
                "  \"autoGeneratedParams\": {AI自动生成的参数},\n" +
                "  \"intent\": \"简短描述用户意图\"\n" +
                "}\n\n" +
                "3. 参数提取和生成规则：\n" +
                "   - 从用户消息中提取明确提到的参数\n" +
                "   - **对于必填但用户未提供的参数，智能生成合理的值**\n" +
                "   - 将AI生成的参数放入autoGeneratedParams字段\n" +
                "   - 常见字段生成规则：\n" +
                "     * username: 用拼音或英文，如\"zhangsan\"\n" +
                "     * password: 生成强密码，如\"User@123456\"\n" +
                "     * roleCode/deptCode: 用大写英文，如\"ADMIN_ROLE\"\n" +
                "     * email: 基于姓名生成，如\"zhangsan@example.com\"\n" +
                "     * phone: 生成示例手机号，如\"13800138000\"\n" +
                "     * realName: 使用用户提到的姓名\n" +
                "     * status: 默认1（启用）\n" +
                "   - 对于分页参数：current默认1，size默认10\n\n" +
                "4. 示例：\n" +
                "用户：\"添加一个用户张三\"\n" +
                "返回：{\n" +
                "  \"needCall\": true,\n" +
                "  \"method\": \"POST\",\n" +
                "  \"path\": \"/system/user/add\",\n" +
                "  \"parameters\": {\n" +
                "    \"body\": {\n" +
                "      \"username\": \"zhangsan\",\n" +
                "      \"password\": \"ZhangSan@123\",\n" +
                "      \"realName\": \"张三\",\n" +
                "      \"email\": \"zhangsan@example.com\",\n" +
                "      \"phone\": \"13800138001\"\n" +
                "    }\n" +
                "  },\n" +
                "  \"autoGeneratedParams\": {\n" +
                "    \"username\": \"zhangsan\",\n" +
                "    \"password\": \"ZhangSan@123\",\n" +
                "    \"email\": \"zhangsan@example.com\",\n" +
                "    \"phone\": \"13800138001\"\n" +
                "  },\n" +
                "  \"intent\": \"添加用户张三\"\n" +
                "}\n\n" +
                "5. 只返回JSON，不要有其他解释文字。";
    }
    
    /**
     * 解析Function Call JSON
     */
    private FunctionCallRequest parseFunctionCall(String aiResponse) {
        try {
            // 清理可能的markdown代码块标记
            String json = aiResponse.trim();
            if (json.startsWith("```json")) {
                json = json.substring(7);
            }
            if (json.startsWith("```")) {
                json = json.substring(3);
            }
            if (json.endsWith("```")) {
                json = json.substring(0, json.length() - 3);
            }
            json = json.trim();
            
            // 解析JSON
            Map<String, Object> result = objectMapper.readValue(json, 
                    new TypeReference<Map<String, Object>>() {});
            
            // 检查是否需要调用API
            Boolean needCall = (Boolean) result.get("needCall");
            if (needCall == null || !needCall) {
                return null; // 不需要调用API
            }
            
            // 构建FunctionCallRequest
            FunctionCallRequest request = new FunctionCallRequest();
            request.setMethod((String) result.get("method"));
            request.setPath((String) result.get("path"));
            request.setIntent((String) result.get("intent"));
            
            @SuppressWarnings("unchecked")
            Map<String, Object> parameters = (Map<String, Object>) result.get("parameters");
            request.setParameters(parameters);
            
            // 提取AI自动生成的参数
            @SuppressWarnings("unchecked")
            Map<String, Object> autoGenerated = (Map<String, Object>) result.get("autoGeneratedParams");
            if (autoGenerated != null && !autoGenerated.isEmpty()) {
                request.setAutoGeneratedParams(autoGenerated);
            }
            
            return request;
            
        } catch (Exception e) {
            log.error("解析Function Call失败: " + e.getMessage(), e);
            return null;
        }
    }
    
    /**
     * 格式化API执行结果为用户友好的文本
     * 让AI分析API返回的数据，并用自然语言总结
     */
    public String formatApiResult(FunctionCallRequest functionCall, 
                                   ApiExecutorService.ApiExecutionResult result) {
        try {
            if (!result.isSuccess()) {
                // 所有错误都让AI分析，给出更友好的建议
                String errorContext = result.getError();
                String responseData = result.getResponse() != null ? result.getResponse() : "";
                
                // 构建完整的错误信息
                String fullErrorInfo = errorContext;
                if (!responseData.isEmpty()) {
                    fullErrorInfo += "\n\n服务器响应：" + responseData;
                }
                
                return analyzeApiResult(
                    functionCall.getIntent(), 
                    fullErrorInfo, 
                    true, 
                    errorContext
                );
            }
            
            // 成功：让AI分析返回数据
            String aiSummary = analyzeApiResult(
                functionCall.getIntent(), 
                result.getResponse(), 
                false, 
                null
            );
            
            // 如果有自动生成的参数，追加说明
            if (functionCall.hasAutoGeneratedParams()) {
                aiSummary += buildAutoGeneratedParamsNotice(functionCall.getAutoGeneratedParams());
            }
            
            return aiSummary;
            
        } catch (Exception e) {
            log.error("格式化结果失败: " + e.getMessage(), e);
            return "⚠️ 操作完成，但结果分析失败";
        }
    }
    
    /**
     * 使用AI分析API返回结果，生成友好的总结
     */
    private String analyzeApiResult(String intent, String apiResponse, boolean isFailed, String errorMessage) {
        try {
            // 构建分析提示词
            String systemPrompt = "你是一个智能业务助手，负责分析系统API返回的数据和错误信息。\n\n" +
                    "核心原则：\n" +
                    "- **你是在帮用户操作系统，不是在教用户怎么操作**\n" +
                    "- 成功就直接告知结果和关键信息\n" +
                    "- 失败就简要说明原因，不要给出操作教程\n\n" +
                    "规则：\n" +
                    "1. **成功时**：\n" +
                    "   - 用简洁的语言确认操作结果\n" +
                    "   - 提取并展示关键数据\n" +
                    "   - 使用表格或列表清晰呈现\n" +
                    "2. **失败时**：\n" +
                    "   - 简明扼要说明失败原因（1-2句话）\n" +
                    "   - 如果是数据问题（重复、格式错误等），说明具体是什么数据有问题\n" +
                    "   - **不要给出操作步骤教程**\n" +
                    "   - **不要建议用户手动操作页面**\n" +
                    "3. 忽略技术细节（如code、timestamp、stacktrace、HTTP状态码等）\n" +
                    "4. 语气像助手，不像客服\n\n" +
                    "常见错误的回复方式：\n" +
                    "- 字段缺失 → \"添加失败，缺少{字段名}\"\n" +
                    "- 数据重复 → \"添加失败，{数据}已存在\"\n" +
                    "- 权限不足 → \"操作失败，当前账号没有权限\"\n" +
                    "- 参数错误 → \"操作失败，{参数}格式不正确\"\n\n" +
                    "禁止的回复模式：\n" +
                    "❌ \"建议你这样操作：1. 检查表单 2. 核对格式...\"\n" +
                    "❌ \"您可以联系系统管理员\"\n" +
                    "❌ \"请刷新页面重试\"\n" +
                    "✅ \"添加失败，用户名已存在\"\n" +
                    "✅ \"添加成功！\"";
            
            String userPrompt;
            if (isFailed) {
                userPrompt = "用户操作：" + intent + "\n\n" +
                        "❌ 操作失败！\n" +
                        "错误信息：" + errorMessage + "\n\n" +
                        "API返回数据：\n```json\n" + apiResponse + "\n```\n\n" +
                        "请告诉用户为什么失败，以及如何解决。用友好的语气。";
            } else {
                userPrompt = "用户操作：" + intent + "\n\n" +
                        "✅ 操作成功！\n" +
                        "API返回数据：\n```json\n" + apiResponse + "\n```\n\n" +
                        "请分析这个结果并用友好的方式告诉用户。";
            }
            
            List<Message> messages = new ArrayList<>();
            messages.add(Message.builder()
                    .role(Role.SYSTEM.getValue())
                    .content(systemPrompt)
                    .build());
            messages.add(Message.builder()
                    .role(Role.USER.getValue())
                    .content(userPrompt)
                    .build());
            
            Generation gen = new Generation();
            GenerationParam param = GenerationParam.builder()
                    .apiKey(qwenConfig.getApiKey())
                    .model(qwenConfig.getModel())
                    .messages(messages)
                    .resultFormat(GenerationParam.ResultFormat.MESSAGE)
                    .temperature(0.5f) // 适中的温度，平衡准确性和友好度
                    .build();
            
            GenerationResult result = gen.call(param);
            String aiAnalysis = result.getOutput().getChoices().get(0).getMessage().getContent();
            
            log.info("AI数据分析结果: {}", aiAnalysis);
            
            return aiAnalysis;
            
        } catch (Exception e) {
            log.error("AI分析结果失败: " + e.getMessage(), e);
            // 降级方案：直接美化JSON返回
            return formatJsonFallback(intent, apiResponse, isFailed, errorMessage);
        }
    }
    
    /**
     * 构建自动生成参数的提示信息
     */
    private String buildAutoGeneratedParamsNotice(Map<String, Object> autoGeneratedParams) {
        if (autoGeneratedParams == null || autoGeneratedParams.isEmpty()) {
            return "";
        }
        
        StringBuilder notice = new StringBuilder();
        notice.append("\n\n---\n");
        notice.append("**🤖 AI自动补全的信息：**\n");
        
        for (Map.Entry<String, Object> entry : autoGeneratedParams.entrySet()) {
            String key = entry.getKey();
            Object value = entry.getValue();
            
            // 翻译字段名
            String fieldName = translateFieldName(key);
            
            // 处理密码字段的显示
            if (key.toLowerCase().contains("password")) {
                notice.append("• ").append(fieldName).append("：`").append(value).append("`")
                      .append(" ⚠️ *请首次登录后修改*\n");
            } else {
                notice.append("• ").append(fieldName).append("：`").append(value).append("`\n");
            }
        }
        
        notice.append("\n💡 *这些信息由AI自动生成，您也可以明确指定*");
        
        return notice.toString();
    }
    
    /**
     * 翻译字段名为中文
     */
    private String translateFieldName(String fieldName) {
        switch (fieldName) {
            case "username": return "用户名";
            case "password": return "密码";
            case "realName": return "真实姓名";
            case "email": return "邮箱";
            case "phone": return "手机号";
            case "roleCode": return "角色编码";
            case "roleName": return "角色名称";
            case "deptCode": return "部门编码";
            case "deptName": return "部门名称";
            case "status": return "状态";
            case "description": return "描述";
            default: return fieldName;
        }
    }
    
    /**
     * 降级方案：直接格式化JSON
     */
    private String formatJsonFallback(String intent, String apiResponse, boolean isFailed, String errorMessage) {
        try {
            StringBuilder message = new StringBuilder();
            
            if (isFailed) {
                message.append("❌ ").append(intent).append(" - 失败\n\n");
                message.append("**错误原因：**\n").append(errorMessage).append("\n\n");
            } else {
                message.append("✅ ").append(intent).append("\n\n");
            }
            
            // 尝试美化JSON
            Object jsonObj = objectMapper.readValue(apiResponse, Object.class);
            String prettyJson = objectMapper.writerWithDefaultPrettyPrinter()
                    .writeValueAsString(jsonObj);
            message.append("**详细信息：**\n");
            message.append("```json\n").append(prettyJson).append("\n```");
            
            return message.toString();
        } catch (Exception e) {
            if (isFailed) {
                return "❌ " + intent + " - 失败\n\n" + errorMessage;
            } else {
                return "✅ " + intent + "\n\n" + apiResponse;
            }
        }
    }
}

